import express from 'express';
import multer from 'multer';
import path from 'path';
import fs from 'fs';
import { fileURLToPath } from 'url';
import openai from 'openai';

import db, { query } from '../db.js';
import { authenticateToken } from '../middleware/authMiddleware.js';
import { SERVER_CONFIG } from '../config.js';

const router = express.Router();
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// 保存处理状态的映射
const processStatusMap = new Map();

// 记录是否需要终止当前所有AI任务的标志
let terminateAllTasks = false;

// 处理状态状态枚举
const ProcessStatus = {
  PENDING: 'pending',        // 待处理
  READING: 'reading',        // 正在读取文件
  PROCESSING: 'processing',  // AI处理中
  SAVING: 'saving',          // 保存到数据库
  COMPLETED: 'completed',    // 完成
  FAILED: 'failed',          // 失败
  TERMINATED: 'terminated'   // 被用户终止
};

// 创建文档上传目录
const docsDir = path.join(SERVER_CONFIG.UPLOADS_DIR, 'docs');
if (!fs.existsSync(docsDir)) {
  fs.mkdirSync(docsDir, { recursive: true });
  console.log('已创建文档目录:', docsDir);
}

// 配置文档上传存储
const docStorage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, docsDir);
  },
  filename: (req, file, cb) => {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    const ext = path.extname(file.originalname);
    cb(null, 'doc-' + uniqueSuffix + ext);
  }
});

// 设置文件过滤器
const fileFilter = (req, file, cb) => {
  const allowedTypes = /docx|pdf/;
  const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
  const mimetype = file.mimetype === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' || 
                   file.mimetype === 'application/pdf';
  
  if (extname && mimetype) {
    return cb(null, true);
  } else {
    cb(new Error('只允许上传Word(.docx)和PDF(.pdf)文件!'));
  }
};

// 配置上传中间件
const uploadDoc = multer({ 
  storage: docStorage,
  limits: { fileSize: 20 * 1024 * 1024 }, // 20MB
  fileFilter: fileFilter
});

// 读取Word文档内容
const readDocxFile = async (filePath) => {
  try {
    const { execFile } = await import('child_process');
    const { promisify } = await import('util');
    const execFilePromise = promisify(execFile);
    
    // 创建临时脚本文件，添加编码处理
    const scriptPath = path.join(__dirname, '../temp_script.py');
    fs.writeFileSync(scriptPath, `
import sys
import io
from docx import Document

# 设置标准输出编码为utf-8
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

try:
    doc = Document("${filePath.replace(/\\/g, '\\\\')}")
    text = []
    for para in doc.paragraphs:
        if para.text:
            text.append(para.text)
    
    # 打印文本时确保编码正确
    print("\\n".join(text))
except Exception as e:
    print(f"读取文档时出错: {str(e)}", file=sys.stderr)
    sys.exit(1)
    `);
    
    // 执行Python脚本，指定编码为utf-8
    const { stdout } = await execFilePromise('python', [scriptPath], {
      encoding: 'utf8',
      env: { ...process.env, PYTHONIOENCODING: 'utf-8' }
    });
    
    // 删除临时脚本
    fs.unlinkSync(scriptPath);
    
    // 检查输出内容是否为空或包含乱码
    if (!stdout || stdout.trim() === '' || /\uFFFD|\u003F\u003F\u003F/.test(stdout)) {
      console.log('[WARNING] 检测到可能的乱码或空内容，尝试使用二进制方式读取');
      
      // 创建另一个临时脚本，使用二进制方式读取
      const binaryScriptPath = path.join(__dirname, '../temp_binary_script.py');
      fs.writeFileSync(binaryScriptPath, `
import sys
import io
import base64
from docx import Document

# 设置标准输出编码为utf-8
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

try:
    doc = Document("${filePath.replace(/\\/g, '\\\\')}")
    text = []
    for para in doc.paragraphs:
        if para.text:
            # 使用base64编码文本以避免编码问题
            encoded_text = base64.b64encode(para.text.encode('utf-8')).decode('ascii')
            text.append(encoded_text)
    
    # 输出base64编码的文本，以JSON格式输出以防止格式问题
    import json
    print(json.dumps(text))
except Exception as e:
    print(f"二进制读取文档时出错: {str(e)}", file=sys.stderr)
    sys.exit(1)
      `);
      
      // 执行二进制Python脚本
      const { stdout: binaryStdout } = await execFilePromise('python', [binaryScriptPath], {
        encoding: 'utf8',
        env: { ...process.env, PYTHONIOENCODING: 'utf-8' }
      });
      
      // 删除临时脚本
      fs.unlinkSync(binaryScriptPath);
      
      // 解析JSON结果并解码base64文本
      try {
        const encodedLines = JSON.parse(binaryStdout);
        const decodedText = encodedLines.map(line => {
          const buff = Buffer.from(line, 'base64');
          return buff.toString('utf-8');
        }).join('\n');
        
        console.log('[INFO] 成功使用二进制方式读取文档');
        return decodedText;
      } catch (jsonError) {
        console.error('[ERROR] 解析二进制结果失败:', jsonError);
        throw new Error('无法正确解析文档内容');
      }
    }
    
    return stdout;
  } catch (error) {
    console.error('读取Word文档时出错:', error);
    throw error;
  }
};

// 读取PDF文档内容
const readPdfFile = async (filePath) => {
  try {
    const { execFile } = await import('child_process');
    const { promisify } = await import('util');
    const execFilePromise = promisify(execFile);
    
    // 创建临时脚本文件，添加编码处理
    const scriptPath = path.join(__dirname, '../temp_script.py');
    fs.writeFileSync(scriptPath, `
import sys
import io
import PyPDF2

# 设置标准输出编码为utf-8
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

try:
    with open("${filePath.replace(/\\/g, '\\\\')}", 'rb') as file:
        pdf_reader = PyPDF2.PdfReader(file)
        full_text = []
        
        for page_num in range(len(pdf_reader.pages)):
            page = pdf_reader.pages[page_num]
            extracted_text = page.extract_text()
            if extracted_text:
                full_text.append(extracted_text)
        
        # 打印文本时确保编码正确
        print("\\n".join(full_text))
except Exception as e:
    print(f"读取PDF文档时出错: {str(e)}", file=sys.stderr)
    sys.exit(1)
    `);
    
    // 执行Python脚本，指定编码为utf-8
    const { stdout } = await execFilePromise('python', [scriptPath], {
      encoding: 'utf8',
      env: { ...process.env, PYTHONIOENCODING: 'utf-8' }
    });
    
    // 删除临时脚本
    fs.unlinkSync(scriptPath);
    
    return stdout;
  } catch (error) {
    console.error('读取PDF文档时出错:', error);
    throw error;
  }
};

// 处理文档内容，生成Markdown
const processDocumentWithAI = async (docContent, prompt, apiKey, baseUrl, model, processId) => {
  try {
    // 如果设置了终止所有任务的标志，则直接返回
    if (terminateAllTasks || (processStatusMap.has(processId) && processStatusMap.get(processId).status === ProcessStatus.TERMINATED)) {
      updateProcessStatus(processId, ProcessStatus.TERMINATED, new Error('任务已被用户终止'), '任务被终止');
      console.log(`[DEBUG] 处理文档 [${processId}]: 任务被终止标志检测到，停止处理`);
      return "任务已被用户终止，生成过程已中断。";
    }
    
    // 更新状态为AI处理中
    updateProcessStatus(processId, ProcessStatus.PROCESSING, null, '正在使用AI进行内容处理...');
    
    // 添加调试信息
    console.log(`[DEBUG] 处理文档 [${processId}]: 开始AI处理`);
    console.log(`[DEBUG] API配置: baseURL=${baseUrl || SERVER_CONFIG.AI_BASE_URL}`);
    console.log(`[DEBUG] 使用模型: ${model || SERVER_CONFIG.AI_MODEL}`);
    
    const client = new openai.OpenAI({
      apiKey: apiKey || SERVER_CONFIG.AI_API_KEY,
      baseURL: baseUrl || SERVER_CONFIG.AI_BASE_URL 
    });
    
    // 使用ES6字符串模板，并正确转义反引号
    const fullPrompt = `${prompt}\n\n文档内容:\n${docContent}\n\n请以Markdown格式生成响应，不要添加任何前缀说明，直接开始输出Markdown内容。输出内容中不要有\`\`\`markdown前缀，也不要有\`\`\`后缀`;
    
    // 更新状态为正在发送请求
    updateProcessStatus(processId, ProcessStatus.PROCESSING, null, '正在向AI发送请求...');
    
    // 创建一个对话，使用streaming模式获取实时内容
    let partialContent = '';
    let completeContent = '';
    
    try {
      const response = await client.chat.completions.create({
        model: model || SERVER_CONFIG.AI_MODEL,
        messages: [
          { role: "user", content: fullPrompt }
        ],
        max_tokens: 4000,
        temperature: 0.7,
        stream: true // 启用流式传输
      });

      // 处理流式响应
      for await (const chunk of response) {
        // 检查是否需要终止
        if (terminateAllTasks || (processStatusMap.has(processId) && processStatusMap.get(processId).status === ProcessStatus.TERMINATED)) {
          console.log(`[DEBUG] 处理文档 [${processId}]: 流式生成过程中检测到终止标志，停止处理`);
          updateProcessStatus(processId, ProcessStatus.TERMINATED, new Error('任务已被用户终止'), '任务被终止');
          return completeContent || "任务已被用户终止，生成过程已中断。";
        }
        
        const content = chunk.choices[0]?.delta?.content || '';
        if (content) {
          completeContent += content;
          partialContent += content;
          
          // 每当收到新内容就更新状态，不等待积累
          // 计算动态进度 (40-80%之间)
          const estimatedProgress = Math.min(80, 40 + Math.floor(completeContent.length / 50));
          
          // 更新处理状态，直接显示最新内容
          // 保留最后5行内容，确保实时展示最新生成的内容
          const contentLines = completeContent.split('\n');
          const lastLines = contentLines.slice(-5).join('\n');
          
          updateProcessStatus(
            processId, 
            ProcessStatus.PROCESSING, 
            null, 
            `正在生成内容... 已接收 ${completeContent.length} 字符\n最近内容: ${lastLines}`
          );
        }
      }
      
      console.log(`[DEBUG] 处理文档 [${processId}]: AI响应完成，生成内容长度 ${completeContent.length} 字符`);
      return completeContent;
      
    } catch (streamError) {
      console.error('[ERROR] 流式处理失败，尝试使用非流式模式:', streamError);
      
      // 如果流式处理失败，尝试使用非流式模式
      updateProcessStatus(processId, ProcessStatus.PROCESSING, null, '流式处理失败，尝试使用标准模式...');
      
      // 检查是否需要终止
      if (terminateAllTasks || (processStatusMap.has(processId) && processStatusMap.get(processId).status === ProcessStatus.TERMINATED)) {
        console.log(`[DEBUG] 处理文档 [${processId}]: 标准模式开始前检测到终止标志，停止处理`);
        updateProcessStatus(processId, ProcessStatus.TERMINATED, new Error('任务已被用户终止'), '任务被终止');
        return "任务已被用户终止，生成过程已中断。";
      }
      
      const standardResponse = await client.chat.completions.create({
        model: model || SERVER_CONFIG.AI_MODEL,
        messages: [
          { role: "user", content: fullPrompt }
        ],
        max_tokens: 4000,
        temperature: 0.7
      });
      
      return standardResponse.choices[0].message.content;
    }
  } catch (error) {
    console.error('AI处理时出错:', error);
    throw error;
  }
};

// 生成唯一的处理ID
const generateProcessId = () => {
  return Date.now().toString(36) + Math.random().toString(36).substring(2, 7);
};

// 更新处理状态
const updateProcessStatus = (processId, status, error = null, message = '') => {
  if (!processStatusMap.has(processId)) {
    processStatusMap.set(processId, {
      status: ProcessStatus.PENDING,
      progress: 0,
      message: '初始化中...',
      error: null,
      startTime: Date.now(),
      updateTime: Date.now(),
      result: null
    });
  }
  
  const currentStatus = processStatusMap.get(processId);
  
  // 更新状态
  currentStatus.status = status;
  currentStatus.updateTime = Date.now();
  
  // 根据状态更新进度
  switch (status) {
    case ProcessStatus.PENDING:
      currentStatus.progress = 5;
      break;
    case ProcessStatus.READING:
      currentStatus.progress = 15;
      break;
    case ProcessStatus.PROCESSING:
      currentStatus.progress = 40;
      break;
    case ProcessStatus.SAVING:
      currentStatus.progress = 85;
      break;
    case ProcessStatus.COMPLETED:
      currentStatus.progress = 100;
      break;
    case ProcessStatus.FAILED:
      currentStatus.error = error;
      currentStatus.message = '处理失败: ' + (error?.message || '未知错误');
      break;
    case ProcessStatus.TERMINATED:
      currentStatus.progress = currentStatus.progress; // 保持当前进度
      currentStatus.error = error;
      currentStatus.message = '已终止: ' + (error?.message || '用户手动终止');
      break;
  }
  
  // 如果有提供自定义消息
  if (message) {
    currentStatus.message = message;
  }
  
  // 15分钟后自动清理处理状态
  setTimeout(() => {
    if (processStatusMap.has(processId)) {
      console.log(`自动清理处理状态: ${processId}`);
      processStatusMap.delete(processId);
    }
  }, 15 * 60 * 1000);
  
  console.log(`处理状态更新 [${processId}]: ${status}, 进度: ${currentStatus.progress}%, 消息: ${currentStatus.message}`);
};

// 上传并处理文档
router.post('/process-document', authenticateToken, uploadDoc.single('document'), async (req, res) => {
  // 生成唯一处理ID
  const processId = generateProcessId();
  
  // 初始化进度状态
  updateProcessStatus(processId, ProcessStatus.PENDING, null, '正在准备处理...');
  
  // 用异步方式处理文档，返回处理ID
  res.status(202).json({
    message: '文档处理已开始',
    processId: processId
  });
  
  // 异步执行后续处理
  processDocument(req, processId).catch(error => {
    console.error(`处理ID ${processId} 的文档处理失败:`, error);
    updateProcessStatus(processId, ProcessStatus.FAILED, error);
  });
});

// 异步处理文档的函数
const processDocument = async (req, processId) => {
  try {
    if (!req.file) {
      updateProcessStatus(processId, ProcessStatus.FAILED, new Error('没有上传文件'));
      return;
    }
    
    const { prompt } = req.body;
    if (!prompt) {
      updateProcessStatus(processId, ProcessStatus.FAILED, new Error('需要提供处理指令(prompt)'));
      return;
    }
    
    const filePath = req.file.path;
    const fileExt = path.extname(filePath).toLowerCase();
    
    // 更新状态为读取文件中
    updateProcessStatus(processId, ProcessStatus.READING, null, '正在读取文档内容...');
    console.log(`[DEBUG] 处理文档 [${processId}]: 开始读取文件 ${filePath}`);
    
    // 获取用户ID
    const userId = req.user.userId;
    
    // 获取用户自定义AI设置
    let userApiKey = req.body.apiKey;
    let userBaseUrl = req.body.baseUrl;
    let userModel = req.body.model;
    
    // 如果请求中没有提供API设置，尝试从用户设置中获取
    if (!userApiKey || !userBaseUrl || !userModel) {
      try {
        const [userSettings] = await query(
          'SELECT api_key, base_url, model FROM user_ai_settings WHERE user_id = ? AND (api_key IS NOT NULL OR base_url IS NOT NULL OR model IS NOT NULL)',
          [userId]
        );
        
        if (userSettings) {
          console.log(`[DEBUG] 处理文档 [${processId}]: 使用用户自定义AI设置`);
          // 优先使用请求中提供的参数，其次使用用户配置
          userApiKey = userApiKey || userSettings.api_key;
          userBaseUrl = userBaseUrl || userSettings.base_url;
          userModel = userModel || userSettings.model;
        }
      } catch (settingsError) {
        console.error('获取用户AI设置失败:', settingsError);
        // 获取失败时不中断处理流程，继续使用默认设置
      }
    }
    
    // 根据文件类型读取内容
    let docContent;
    if (fileExt === '.docx') {
      docContent = await readDocxFile(filePath);
    } else if (fileExt === '.pdf') {
      docContent = await readPdfFile(filePath);
    } else {
      updateProcessStatus(processId, ProcessStatus.FAILED, new Error('不支持的文件格式'));
      return;
    }
    
    if (!docContent) {
      updateProcessStatus(processId, ProcessStatus.FAILED, new Error('无法读取文档内容'));
      return;
    }
    
    console.log(`[DEBUG] 处理文档 [${processId}]: 读取到内容 ${docContent.length} 字符`);
    
    // 使用AI处理文档内容
    const markdownContent = await processDocumentWithAI(
      docContent, 
      prompt,
      userApiKey,
      userBaseUrl,
      userModel,
      processId
    );
    
    // 更新状态为保存到数据库
    updateProcessStatus(processId, ProcessStatus.SAVING, null, '正在保存处理结果...');
    
    // 调试输出用户信息
    console.log(`[DEBUG] 处理文档 [${processId}]: 用户信息:`, req.user);
    console.log(`[DEBUG] 处理文档 [${processId}]: 用户ID字段值(req.user.userId): ${userId}`);
    
    // 如果userId字段不存在，则检查其他可能的字段名称
    if (!userId) {
      const possibleUserIdFields = ['userId', 'id', 'user_id'];
      console.log(`[DEBUG] 处理文档 [${processId}]: 尝试其他可能的用户ID字段...`);
      
      for (const field of possibleUserIdFields) {
        if (req.user[field]) {
          console.log(`[DEBUG] 处理文档 [${processId}]: 找到字段 ${field} 值为 ${req.user[field]}`);
        }
      }
      
      // 如果找不到合适的ID字段，则失败
      if (!possibleUserIdFields.some(field => req.user[field])) {
        updateProcessStatus(processId, ProcessStatus.FAILED, new Error('用户ID不能为空，请检查用户认证'));
        return;
      }
    }
    
    // 尝试从req.user中获取任何可能的用户ID字段
    const effectiveUserId = userId || req.user.id || req.user.user_id;
    
    if (!effectiveUserId) {
      updateProcessStatus(processId, ProcessStatus.FAILED, new Error('无法确定用户ID'));
      return;
    }
    
    // 从AI生成的内容中提取标题
    let docTitle = req.body.title || `AI生成: ${path.basename(req.file.originalname, fileExt)}`;
    
    // 检查内容中是否包含</think>标记和Markdown标题格式
    // 支持多种可能的格式：
    // 1. </think># 标题
    // 2. </think> # 标题
    // 3. </think>后任意空白字符，然后是#开头的标题
    const thinkEndRegex = /<\/think>[\s\n]*#\s+([^\n]+)/;
    const headerRegex = /^#\s+([^\n]+)/m;  // 匹配文档开头的"# 标题"格式
    
    let thinkMatch = markdownContent.match(thinkEndRegex);
    
    if (thinkMatch && thinkMatch[1]) {
      // 使用提取的标题
      docTitle = thinkMatch[1].trim();
      console.log(`[DEBUG] 处理文档 [${processId}]: 从</think>标记中提取标题: ${docTitle}`);
    } else {
      // 如果没有</think>标记，检查文档是否以Markdown标题开头
      const headerMatch = markdownContent.match(headerRegex);
      if (headerMatch && headerMatch[1]) {
        docTitle = headerMatch[1].trim();
        console.log(`[DEBUG] 处理文档 [${processId}]: 从文档开头提取标题: ${docTitle}`);
      }
    }
    
    console.log(`[DEBUG] 处理文档 [${processId}]: 准备保存到数据库，有效用户ID=${effectiveUserId}, 标题=${docTitle}`);
    
    try {
      // 使用导入的query辅助函数执行SQL查询
      const result = await query(
        'INSERT INTO documents (user_id, title, content, created_at, updated_at) VALUES (?, ?, ?, NOW(), NOW())',
        [effectiveUserId, docTitle, markdownContent]
      );
      
      console.log(`[DEBUG] 处理文档 [${processId}]: 数据库插入结果:`, result);
      const docId = result.insertId;
      
      // 删除临时上传的文件
      fs.unlinkSync(filePath);
      
      // 更新处理状态为完成
      updateProcessStatus(processId, ProcessStatus.COMPLETED, null, '处理完成');
      
      // 保存结果
      processStatusMap.get(processId).result = {
        docId: docId,
        title: docTitle
      };
    } catch (dbError) {
      console.error(`[ERROR] 数据库操作失败:`, dbError);
      throw new Error(`数据库操作失败: ${dbError.message}`);
    }
  } catch (error) {
    console.error('处理文档时出错:', error);
    updateProcessStatus(processId, ProcessStatus.FAILED, error);
  }
};

// 获取处理进度
router.get('/process-status/:processId', async (req, res) => {
  const { processId } = req.params;
  
  if (!processStatusMap.has(processId)) {
    return res.status(404).json({ 
      message: '找不到指定的处理任务',
      processId: processId
    });
  }
  
  const processStatus = processStatusMap.get(processId);
  
  // 如果状态是已完成，同时返回结果
  if (processStatus.status === ProcessStatus.COMPLETED && processStatus.result) {
    return res.json({
      ...processStatus,
      result: processStatus.result
    });
  }
  
  // 否则只返回进度信息
  res.json({
    status: processStatus.status,
    progress: processStatus.progress,
    message: processStatus.message,
    error: processStatus.error ? processStatus.error.message : null
  });
});

// 获取AI设置
router.get('/settings', authenticateToken, (req, res) => {
  res.json({
    defaultApiKey: SERVER_CONFIG.AI_API_KEY ? '已配置' : undefined,
    defaultBaseUrl: SERVER_CONFIG.AI_BASE_URL,
    defaultModel: SERVER_CONFIG.AI_MODEL,
    maxFileSize: '20MB'
  });
});

// 获取用户自定义AI设置
router.get('/user-settings', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.userId;
    
    // 从数据库获取用户自定义AI设置
    const [userSettings] = await query(
      'SELECT api_key, base_url, model FROM user_ai_settings WHERE user_id = ?',
      [userId]
    );
    
    if (!userSettings) {
      // 如果用户没有自定义设置，返回空对象
      return res.json({
        apiKey: '',
        baseUrl: '',
        model: ''
      });
    }
    
    // 返回用户自定义设置
    res.json({
      apiKey: userSettings.api_key || '',
      baseUrl: userSettings.base_url || '',
      model: userSettings.model || ''
    });
  } catch (error) {
    console.error('获取用户AI设置失败:', error);
    res.status(500).json({ message: '获取用户AI设置失败' });
  }
});

// 保存用户自定义AI设置
router.post('/user-settings', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.userId;
    const { apiKey, baseUrl, model } = req.body;
    
    // 检查用户是否已有设置
    const [existingSettings] = await query(
      'SELECT id FROM user_ai_settings WHERE user_id = ?',
      [userId]
    );
    
    if (existingSettings) {
      // 更新现有设置
      await query(
        'UPDATE user_ai_settings SET api_key = ?, base_url = ?, model = ?, updated_at = NOW() WHERE user_id = ?',
        [apiKey, baseUrl, model, userId]
      );
    } else {
      // 创建新设置
      await query(
        'INSERT INTO user_ai_settings (user_id, api_key, base_url, model, created_at, updated_at) VALUES (?, ?, ?, ?, NOW(), NOW())',
        [userId, apiKey, baseUrl, model]
      );
    }
    
    res.json({ message: 'AI设置已保存' });
  } catch (error) {
    console.error('保存用户AI设置失败:', error);
    res.status(500).json({ message: '保存用户AI设置失败' });
  }
});

// 终止特定AI生成进程
router.post('/terminate-process', authenticateToken, (req, res) => {
  try {
    const { processId } = req.body;
    
    if (!processId) {
      return res.status(400).json({ message: '缺少进程ID' });
    }
    
    if (!processStatusMap.has(processId)) {
      return res.status(404).json({ message: '找不到指定的处理任务' });
    }
    
    const processStatus = processStatusMap.get(processId);
    
    // 如果任务已经结束，则返回成功
    if (processStatus.status === ProcessStatus.COMPLETED || 
        processStatus.status === ProcessStatus.FAILED || 
        processStatus.status === ProcessStatus.TERMINATED) {
      return res.json({ message: '任务已经结束' });
    }
    
    // 将进程状态设置为已终止
    processStatus.status = ProcessStatus.TERMINATED;
    processStatus.message = '用户手动终止了处理任务';
    processStatus.error = new Error('用户手动终止了处理任务');
    
    console.log(`[INFO] 用户终止了处理任务: ${processId}`);
    
    res.json({ message: '已成功终止处理任务' });
  } catch (error) {
    console.error('终止处理任务失败:', error);
    res.status(500).json({ message: '终止处理任务失败' });
  }
});

// 终止所有AI生成任务
router.post('/terminate', authenticateToken, (req, res) => {
  try {
    console.log('[INFO] 收到终止所有AI任务的请求');
    
    // 设置全局终止标志
    terminateAllTasks = true;
    
    // 遍历所有正在处理的任务，将其状态更新为已终止
    for (const [processId, status] of processStatusMap.entries()) {
      if (status.status === ProcessStatus.PROCESSING) {
        console.log(`[INFO] 将进程 ${processId} 标记为已终止`);
        updateProcessStatus(
          processId,
          ProcessStatus.TERMINATED,
          new Error('任务已被用户手动终止'),
          '任务已被用户手动终止'
        );
      }
    }
    
    // 1秒后重置终止标志，允许新任务开始
    setTimeout(() => {
      terminateAllTasks = false;
      console.log('[INFO] 终止标志已重置，允许新任务开始');
    }, 1000);
    
    res.json({ 
      message: '所有AI生成任务已终止',
      terminatedCount: Array.from(processStatusMap.values())
        .filter(s => s.status === ProcessStatus.TERMINATED).length
    });
  } catch (error) {
    console.error('终止AI任务时出错:', error);
    res.status(500).json({ message: '终止AI任务失败' });
  }
});

export default router; 